Multiplexing message distribution within group-based communication system

ABSTRACT

Various embodiments are directed to message distribution protocols for a group-based communication platform, in which messages exchanged within a plurality of individual communication channels are provided to client devices via a single websocket connection for each client device. The messages are provided together with associated correspondence tags identifying communication channels in which the messages are exchanged, and the client device disseminates those messages for display in appropriate communication-channel-specific display windows based at least in part on the correspondence tags transmitted with the messages.

BACKGROUND

Systems have been provided for disseminating shared content messageswithin a communication interface among a plurality of client devices viaan at least partially centralized messaging server system.

Through applied effort, ingenuity, and innovation, many of theseidentified deficiencies and problems have been solved by developingsolutions that are in accordance with the embodiments of the presentinvention, many examples of which are described in detail herein

BRIEF SUMMARY

Various embodiments provide multiplexing mechanisms for transmitting aplurality of communication messages (e.g., textual messages, filetransfers, real-time calls, and/or the like) destined for a plurality ofdiscrete communication targets (e.g., communication interfaces) within asingle client device via a single websocket connection between acentralized messaging server system and the client device. Once themessages are received at the target client device, the target clientdevice disseminates the messages for display to a user in associationwith the respective communication targets. For example, messagesprovided to a client device within the context of a first conversation(e.g., displayable within a first discrete window) and messages providedto the same client device within the context of a second conversation(e.g., displayable within a second discrete window), may be transmittedto the client device over a common websocket connection and thendisseminated for display within the appropriate communication windowsonce received at the client device.

Various embodiments are directed to a message distribution system fordisseminating messages to client devices in association with agroup-based communication platform. In certain embodiments, the systemcomprises: one or more message distribution servers configured fordirecting messages shared among client devices within communicationchannels; and at least one multiplexer. The multiplexer may beconfigured to: maintain a websocket connection with a client device ofthe plurality of client devices; and transmit a plurality of messagesshared within respective communication channels from the one or moremessage distribution servers to the client device via the websocketconnection, wherein each of the plurality of messages comprises acorrespondence tag identifying a respective communication channel fordisplay of the respective message on the client device within a displaywindow corresponding to the communication channel.

In certain embodiments, the multiplexer maintains a plurality of backendwebsocket connections with the one or more message distribution servers,wherein the backend websocket connections each correspond with acommunication channel. Moreover, a message of the plurality of messagesmay comprise a plurality of correspondence tags identifying a pluralityof communication channels for display of the respective message. Incertain embodiments, the multiplexer is further configured to: receivean authentication token from the client device identifying a pluralityof communication channels subscribed to by the client device; andtransmit a plurality of messages shared within subscribed communicationchannels from the one or more message distribution servers to the clientdevice via the websocket connection. Moreover, the multiplexer may befurther configured to receive a plurality of join request messages fromthe client device, wherein each join request identifies a communicationchannel to be joined by the client device; and transmit a plurality ofmessages shared within the joined communication channels from the one ormore message distribution servers to the client device via the websocketconnection.

In certain embodiments, maintaining the websocket connection comprises:initializing the websocket connection in response to a first triggerevent to enable transmission of messages to the client device; closingthe websocket connection in response to a second trigger event; andstoring a plurality of messages in a buffer memory while the websocketconnection is closed, such that the plurality of messages stored in thebuffer memory are transmitted to the client device upon initializationof the websocket connection. Moreover, the first trigger event may beselected from: a predetermined time or receipt of a query from theclient device.

Certain embodiments are directed to a method for multiplexing messagesdisseminated to client devices within communication channels inassociation with a group-based communication platform. The method maycomprise: maintaining a websocket connection between a client device anda group-based communication platform; transmitting a plurality ofmessages to the client device via the websocket connection, wherein eachof the plurality of messages comprises a correspondence tag identifyinga respective communication channel for display of the respective messageon the client device within a display window corresponding to thecommunication channel; and displaying the plurality of messages withinrespective display windows on the client device based at least on partthe correspondence tag.

In certain embodiments, a message of the plurality of messages comprisesa plurality of correspondence tags identifying a plurality ofcommunication channels for display of the respective message. Moreover,the method may further comprise: receiving an authentication token fromthe client device identifying a plurality of communication channelssubscribed to by the client device; and transmitting a plurality ofmessages shared within subscribed communication channels from the one ormore message distribution servers to the client device via the websocketconnection.

In various embodiments, the method further comprises: receiving aplurality of join request messages from the client device, wherein eachjoin request identifies a communication channel to be joined by theclient device; and transmitting a plurality of messages shared withinthe joined communication channels to the client device via the websocketconnection. In certain embodiments, maintaining the websocket connectioncomprises: initializing the websocket connection in response to a firsttrigger event to enable transmission of messages to the client device;closing the websocket connection in response to a second trigger event;and storing a plurality of messages in a buffer memory while thewebsocket connection is closed, such that the plurality of messagesstored in the buffer memory are transmitted to the client device uponinitialization of the websocket connection. Moreover, the first triggerevent may be selected from: a predetermined time or receipt of a queryfrom the client device.

Certain embodiments are directed to a client device for displayingmessages exchanged within communication channels associated with agroup-based communication platform. In various embodiments, the clientdevice comprises: one or more memory storage areas; and one or moreprocessors collectively configured to: maintain a websocket connectionwith a group-based communication platform via a communication interface;receive a plurality of messages from the group-based communicationplatform via the websocket connection, wherein each of the plurality ofmessages comprise a correspondence tag identifying a respectivecommunication channel for display of the respective message on theclient device within a display window corresponding to the communicationchannel; disseminate the received plurality of messages for displaywithin respective communication windows based at least in part on thecorrespondence tags associated with the messages.

In various embodiments, disseminating the received plurality of messagescomprises: providing each of the plurality of messages to each of theplurality of display windows; and filtering the plurality of messages ateach display window based at least in part on the correspondence tags tostore and display relevant messages at each respective display window.In certain embodiments, disseminating the received plurality of messagescomprises: providing each of the plurality of messages to respectivedisplay windows based at least in part on the correspondence tagsassociated with the messages; and displaying the messages received ateach display window. Moreover, maintaining the websocket connectioncomprises: transmitting a query to the group-based communicationplatform; and initializing the websocket connection to enabletransmission of messages in response to the query.

Various embodiments are directed to a method for displaying messagesexchanged within communication channels associated with a group-basedcommunication platform via a client device. In certain embodiments, themethod comprises: maintaining a websocket connection with a group-basedcommunication platform via a communication interface; receiving aplurality of messages from the group-based communication platform viathe websocket connection, wherein each of the plurality of messagescomprise a correspondence tag identifying a respective communicationchannel for display of the respective message on the client devicewithin a display window corresponding to the communication channel;disseminating the received plurality of messages for display withinrespective communication windows based at least in part on thecorrespondence tags associated with the messages.

In various embodiments, disseminating the received plurality of messagescomprises: providing each of the plurality of messages to each of theplurality of display windows; and filtering the plurality of messages ateach display window based at least in part on the correspondence tags tostore and display relevant messages at each respective display window.Moreover, disseminating the received plurality of messages may comprise:providing each of the plurality of messages to respective displaywindows based at least in part on the correspondence tags associatedwith the messages; and displaying the messages received at each displaywindow. In certain embodiments, maintaining the websocket connectioncomprises: transmitting a query to the group-based communicationplatform; and initializing the websocket connection to enabletransmission of messages in response to the query.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

Reference will now be made to the accompanying drawings, which are notnecessarily drawn to scale, and wherein:

FIG. 1 shows a schematic view of a group-based communication platform incommunication with client devices according to one embodiment;

FIG. 2 shows a schematic view of a group-based communication platform incommunication with client devices according to another embodiment;

FIG. 3 shows a schematic view of a message distribution server accordingto one embodiment;

FIG. 4 shows a schematic view of a multiplexer according to oneembodiment;

FIG. 5 shows a schematic view of data transmission interactions betweendisplay windows of a group-based communication interface, according toone embodiment; and

FIGS. 6-7 are flowcharts illustrating the functionality of variouscomputing entities according to various embodiments.

DETAILED DESCRIPTION

The present disclosure more fully describes various embodiments withreference to the accompanying drawings. It should be understood thatsome, but not all embodiments are shown and described herein. Indeed,the embodiments may take many different forms, and accordingly thisdisclosure should not be construed as limited to the embodiments setforth herein. Rather, these embodiments are provided so that thisdisclosure will satisfy applicable legal requirements. Like numbersrefer to like elements throughout.

Overview

As individual users of a group-based communication platform initiateand/or join an increasing number of separate correspondence strings(e.g., group-based communication windows each encompassing one or moregroup-based communication channels, direct message windows, real-timecall windows, and/or the like), the processing burdens placed on themessaging server system similarly increases to maintain open lines ofcommunication for each of these correspondence strings. Specifically,each of these correspondence strings may have an associated websocketconnection between the messaging server system and each client device,which, in many instances, results in a single client device beingconnected with the messaging server system via a plurality of discretewebsocket connections, each of which requires substantial processingresources to maintain. This generally duplicative communication strategycreates substantial burdens on the client devices (e.g., by requiringrelatively high amounts of processing power to maintain the plurality ofopen websocket connections) and the messaging server system (e.g., byrequiring relatively high amounts of processing power to maintain theplurality of open websockets and to restore any websockets that break(e.g., undesirably disconnect) as well as to resend any messages thatmay have been missed by a client device while the websocket connectionis broken).

Various embodiments relate generally to systems and methods fordisseminating messages exchanged over communication channels betweenclient devices via a group-based communication system via consolidatedwebsocket connections between individual client devices and servers ofthe group-based communication system. Each of these consolidatedwebsockets may be utilized to transmit messages, such as text-basedmessages, real-time audio and/or video-based messages, presence messages(e.g., identifying when another user is active/inactive within a group),and/or the like, that are shared within multiple discrete communicationchannels (e.g., connecting multi-user teams and/or connecting individualusers via one-to-one direct messaging channels) to a particular clientdevice. Those messages may be transmitted together with correspondencetags identifying a group to which each message corresponds, and thereceiving client device may parse those messages and respectivecorrespondence tags to display the messages within respective displaywindows corresponding to the appropriate correspondence group. Thus, allmessages destined for a single client device may be transmitted over aconsolidated websocket, regardless of whether those messages were sharedin a single communication channel or multiple communication channels.

Client devices may subscribe to one or more communication channels, suchthat the servers of the group-based communication system provideappropriate messages to the client device via the websocket. Thosesubscriptions may be provided via an Application Programming Interface(API) authentication token identifying the one or more communicationchannels subscribed to by the client device. Alternatively, thesubscriptions may be formed in response to the client devicetransmitting one or more join-request messages identifying one or morecommunication channels to join.

Messages shared within a subscribed channel are received at amultiplexer (e.g., in direct communication with the servers of thegroup-based communication system) and disseminated to appropriate clientdevices via websocket connections corresponding to each client device.The multiplexer may be in communication with the servers of thegroup-based communication system via a plurality of websocketconnections each utilized for disseminating messages destined for asingle client device within a single communication group. However, itshould be understood that the multiplexer may receive messages from theservers via any of a variety of communication protocols to compile thosemessages for dissemination to appropriate client devices. In embodimentsthat do not utilize websocket connections between the multiplexer andthe communication servers, the number of websocket connections utilizedfor disseminating messages to a particular client device may besignificantly lower than the number of channels for which the clientdevice is subscribed.

Moreover, the number of messages transmitted to client devices may beminimized as well. Messages transmitted for display in association withparticular communication channels may be transmitted with one or morecorrespondence tags identifying channels and/or groups for which themessage is associated. Thus, if a particular message is associated witha plurality of channels (e.g., a presence message indicating thatanother member of multiple channels has gone offline), only a singleversion of this message may be sent to the client device, and the clientdevice may display that message in each of a plurality of correspondingchannel display windows.

Moreover, various embodiments provide temporal-based multiplexing forminimizing the number of simultaneously-open websocket connections froma multiplexer. For non-Real-Time Messaging (RTM) messages, a clientdevice may be configured to initialize a websocket connection with themultiplexer in response to the occurrence of a trigger event (e.g., theoccurrence of a particular time, which may be established by the clientdevice or based at least in part on messages received from themultiplexer identifying a particular time for establishing a websocketconnection). The multiplexer and client device may maintain thewebsocket as active while the multiplexer transmits messages to theclient device, and the client device may then close the websocketconnection upon the occurrence of a second trigger event (e.g., uponcompletion of transmission of messages, identified by data transmittedfrom the multiplexer indicating that message transmission is complete;upon receipt of a message from the multiplexer indicating an upcomingwebsocket connection termination). In other embodiments, temporal-basedmultiplexing may be provided by a client device initiating a websocketconnection with the multiplexer periodically, according to a definedschedule. For example, the client device may initialize and maintain awebsocket connection with the multiplexer for a defined time period(e.g., one minute), during which time all messages stored in a buffermemory associated with the client device may be transmitted to theclient device. The client device may then close the websocket connectionfor a second defined period of time (e.g., 9 minutes), and themultiplexer may store any messages destined for the client device duringthe second defined period of time within the buffer memory fortransmission during the next period of open websocket basedcommunication.

Definitions

As used herein, the terms “data,” “content,” “information,” and similarterms may be used interchangeably to refer to data capable of beingtransmitted, received, and/or stored in accordance with embodiments ofthe present invention. Thus, use of any such terms should not be takento limit the spirit and scope of embodiments of the present invention.Further, where a computing device is described herein to receive datafrom another computing device, it will be appreciated that the data maybe received directly from another computing device or may be receivedindirectly via one or more intermediary computing devices, such as, forexample, one or more servers, relays, routers, network access points,base stations, hosts, and/or the like. Similarly, where a computingdevice is described herein to send data to another computing device, itwill be appreciated that the data may be sent directly to anothercomputing device or may be sent indirectly via one or more intermediarycomputing devices, such as, for example, one or more servers, relays,routers, network access points, base stations, hosts, and/or the like.

The term “user” should be understood to refer to an individual, a groupof individuals, business, organization, and the like. Users may access agroup-based communication or messaging system using client devices.“Group-based” is used herein to refer to a system, channel, message, orvirtual environment that has security sufficient such that it isaccessible only to a defined group of users. The group may be defined bycommon access credentials such as those of an organization or commercialenterprise. Access may further be facilitated by a validated request tojoin or an invitation to join transmitted by one group member user toanother non-member user. Group identifiers (defined below) are used toassociate data, information, messages, etc., with specific groups.

The terms “user profile,” “user account,” and “user account details”refer to information associated with a user, including, for example, auser identifier, one or more communication channel identifiers (e.g.,group-based communication channel identifiers) associated withcommunication channels (e.g., group-based communication channels) thatthe user has been granted access to, one or more group identifiers forgroups with which the user is associated, an indication as to whetherthe user is an owner of any group-based communication channels, anindication as to whether the user has any group-based communicationchannel restrictions, a plurality of messages, a plurality of emojis, aplurality of conversations, a plurality of conversation topics, anavatar, an email address, a real name (e.g., John Doe), a username(e.g., jdoe), a password, a time zone, a status, and the like. The useraccount details can include a subset designation of user credentials,such as, for example, login information for the user including theuser's username and password.

The term “client device” refers to computer hardware(s) and/orsoftware(s) that is/are configured to access one or more services madeavailable by one or more servers. The server(s) is/are often (but notalways) on another computer system, in which case the client deviceaccesses the service by way of a network. A client device may beassociated with a group identification, where the group identificationis an electronic indication that suggests a group (e.g., user group)that the user belongs to. Client devices may include, withoutlimitation, smart phones, tablet computers, laptop computers, desktopcomputers, wearable devices, personal computers, enterprise computers,and the like.

The term “group-based communication platform” refers to a collection ofcomputing services that are accessible to one or more client devices,and that are operable to provide access to a plurality of softwareapplications related to operations of databases. In some examples, thegroup-based communication platform may take the form of one or morecentral servers disposed in communication with one or more additionalservers running software applications, and having access to one or moredatabases storing digital content items, application-related data,and/or the like.

The term “communication channel” refers to an information route andassociated circuitry that is used for data exchange between and amongsystems and parts of systems. For example, a communication channel maybe established between and among various client devices, allowing theseclient devices to communicate and share data between and among eachother. These communication channels may be “group-based communicationchannels” established between and among a select group of client devices(and their respective users) for sharing messages among all users of thegroup. The communication channels may also and/or alternatively beone-to-one, direct message communication channels established betweenand among two client devices (and their respective users) for sharingmessages among only those two users.

Multiple communication channels may operate on each of one or morecomputing devices, and therefore a communication channel identifier maybe assigned to a communication channel, which indicates the physicaladdress in a database where related data of that communication channelis stored and which is utilized to identify client devices thatparticipate within the communication channel to receive data exchangedon the communication channel. The communication channel identifiertherefore ensures communication channels remain distinct and separateeven on computing devices associated with a plurality of communicationchannels.

A communication channel may be “public,” which may allow any clientdevice to join and participate in the information sharing through thecommunication channel. A communication channel may be “private,” whichmay restrict data communications in the communication channel to certainclient devices and/or users.

The term “group-based communication channel interface” refers to avirtual communications environment or feed that is configured to displaymessaging communications posted by channel members (e.g., validatedusers accessing the environment using client devices) that are viewableonly to the members of the group. The format of the group-basedcommunication channel interface may appear differently to differentmembers of the group-based communication channel; however, the contentof the group-based communication channel interface (i.e., messagingcommunications) will be displayed to each member of the group-basedcommunication channel. For instance, a common set of group-basedmessaging communications will be displayed to each member of therespective group-based communication channel such that the content ofthe group-based communication channel interface (i.e., messagingcommunications) will not vary per member of the group-basedcommunication channel.

In certain embodiments, the group-based communication channel interfacemay comprise one or more display windows each configured for displayingone or more messages, posts, calls (e.g., audio/video calls, video callsor audio-only calls) provided for exchange via the group-basedcommunication platform. In certain embodiments, the group-basedcommunication channel interface may comprise a main display window (alsoreferred to herein as a parent display window) and a plurality of childdisplay windows. In certain embodiments, the main display window maycomprise a plurality of individual display panes (as shown in the parentdisplay window 501 shown in FIG. 5, herein). For example, each displaypane may be configured to display specific data types. For example, aleft-most pane may provide a listing of channels and/or direct messagesavailable to a user and a right-most (or center pane, in a 3-paneconfiguration) may display the content of a particular channel in whichmessages are exchanged, including displaying all of those displayedmessages. In embodiments in which the main display window comprises3-panes, the right-most pane may comprise additional data regarding aparticular selected message, channel, and/or the like.

As used herein, the terms “messaging communication” and “message” referto any electronically generated digital content object provided by auser using a client device and that is configured for display within agroup-based communication channel interface. Message communications mayinclude any text, image, video, audio, or combination thereof providedby a user (using a client device). For instance, the user may provide amessaging communication that includes text as well as an image and avideo within the messaging communication as message contents. In such acase, the text, image, and video would comprise the messagingcommunication or digital content object. Each message sent or posted toa communication channel (e.g., a group-based communication channel) ofthe group-based communication system includes metadata comprising thefollowing: a sending user identifier, a message identifier, messagecontents, and correspondence tags, such as a group identifier and/or agroup-based communication channel identifier. Each of the foregoingidentifiers may comprise ASCII text, a pointer, a memory address, andthe like. Messages may be generated and/or edited within an individualpane of a group-based communication interface (a single pane beingvisible within a particular display window) and/or messages may begenerated and/or edited within separate display windows (e.g., separatedisplay windows may be utilized for generating postings to be sharedwithin a communication channel and/or for initiating a call with otherusers).

The terms “group identifier” or “team identifier” refer to one or moreitems of data by which a group within a group-based communication systemmay be identified. For example, a group identifier may comprise ASCIItext, a pointer, a memory address, and the like.

The terms “group-based communication channel identifier” or “channelidentifier” refer to one or more items of data by which a group-basedcommunication channel may be identified. For example, a group-basedcommunication channel identifier may comprise ASCII text, a pointer, amemory address, and the like. In certain embodiments, a communicationchannel (whether public or private) may be available for use betweenusers (and their associated client devices) of a common group/team,although cross-group communication channels may be available betweenclient devices associated with users of separate teams. Thus, a channelidentifier may be provided together with one or more group identifiersto specifically identify where data/messages related to the particularcommunication channel are stored.

As discussed herein, “correspondence tags” may comprise one or more of agroup identifier or a channel identifier, and may be transmitted to aclient device together with a message. The correspondence tags may thusidentify a group and/or a channel in which the message is to bedisseminated, thereby enabling a client device to display the message inassociation with the appropriate group and/or channel. In certainembodiments, the correspondence tag may be embodied as a channelidentifier, thereby identifying a channel in which the message isexchanged. In other embodiments, the correspondence tag may be embodiedas a group identifier identifying a group in which the message isexchanged. Moreover, the correspondence tags of certain embodiments maycomprise both channel identifiers and team identifiers.

A “sending user identifier” is associated with a collection of messagesthat are sent by a particular user (i.e., a client device associatedwith the particular user). These messages may be analyzed to determinecontext regarding the user (e.g., the user's expertise or interest in atopic may be determined based on the frequency of mention of the topicor key words associated with the topic within such messages).

Group-based communication system users are organized into organizationgroups (e.g., employees of each company may be a separate organizationgroup) and each organization group may have one or more communicationchannels (e.g., group-based communication channels) to which users maybe assigned or which the users may join (e.g., group-based communicationchannels may represent departments, geographic locations such asoffices, product lines, user interests, topics, issues, and/or thelike). A group identifier may be used to facilitate access control for amessage (e.g., access to the message, such as having the message returnas part of search results in response to a search query, may berestricted to those users having the group identifier associated withtheir user profile). The group identifier may be used to determinecontext for the message (e.g., a description of the group, such as thename of an organization and/or a brief description of the organization,may be associated with the group identifier).

Group-based communication system users may join and/or createcommunication channels (e.g., group-based communication channels). Somegroup-based communication channels may be globally accessible to thoseusers having a particular organizational group identifier associatedwith their user profile (i.e., users who are members of theorganization). Access to some group-based communication channels may berestricted to members of specified groups, whereby the group-basedcommunication channels are accessible to those users having a particulargroup identifier associated with their user profile. The group-basedcommunication channel identifier may be used to facilitate accesscontrol for a message (e.g., access to the message, such as having themessage return as part of search results in response to a search query,may be restricted to those users having the group-based communicationchannel identifier associated with their user profile, or who have theability to join the group-based communication channel). The group-basedcommunication channel identifier may be used to determine context forthe message (e.g., a description of the group-based communicationchannel, such as a description of a project discussed in the group-basedcommunication channel, may be associated with the group-basedcommunication channel identifier).

The term “private group-based communication channel” refers to agroup-based communication channel with restricted access such that it isnot generally accessible and/or searchable by other members of thegroup-based communication system. For example, only those users oradministrators who have knowledge of and permission to access (e.g., agroup-based communication channel identifier for the private group-basedcommunication channel is associated with their user profile after theuser has been validated/authenticated) the private group-basedcommunication channel may view content of the private group-basedcommunication channel.

“Multiplexers” as discussed herein with reference to various embodimentsare computing devices (or portions of computing devices) for maintainingcommunication connections with various client devices. Specifically,multiplexers may be configured for maintaining websocket connectionsinitiated by each of a plurality of client devices for transmittingmessages and corresponding metadata (e.g., comprising correspondencetags) in real time between message distribution servers of thegroup-based communication platform and respective client devices. Themultiplexer may thereby interact with client devices as an interfacecomputing entity for directing message data among client devices bothwithin and outside of the group-based communication platform. Themultiplexers may be the only interface computing entities for exchangingmessages between the group-based communication platform and variousclient devices (e.g., receiving and transmitting messages to and fromthe various client devices), or the multiplexers may be one of aplurality of interface computing entities collectively configured forthe exchange of messages between the group-based communication platformand various client devices. For example, the multiplexers may beconfigured for transmitting messages to various client devices, andother interface computing entities may be configured for receivingmessages transmitted from the various client devices.

In certain embodiments, the multiplexers generate and maintain backendwebsocket connections with one or more message distribution servers asdiscussed herein for obtaining messages to be disseminated to thevarious client devices. The multiplexer-to-server websockets may be eachconfigured for transmitting data exchanged on a single communicationchannel and destined for a single user/client device. For example, afirst websocket may be generated between the multiplexer and the messagedistribution servers for transmitting message data exchanged on “Channel1” communication channel and destined for “User 1.” A second websocketmay be generated between the multiplexer and the message distributionservers for transmitting message data exchanged on the same “Channel 1”communication channel, but destined for “User 2.”

“Message distribution servers” as discussed herein with reference tocertain embodiments are computing devices configured for interactingwith various client devices (e.g., via a multiplexer) for receivingand/or disseminating messages for distribution within communicationchannels. Message distribution servers may be configured to receive,store (in an associated database), and/or direct messages exchangedbetween users (operating via client devices). The functionality of themessage distribution servers may be provided via a single server orcollection of servers having a common functionality, or thefunctionality of the message distribution servers may be segmented amonga plurality of servers or collections of servers performing subsets ofthe described functionality of the message distribution servers. Forexample, a first subset of message distribution servers—gatewayservers—may be configured for receiving messages from client devicesand/or for transmitting messages to client devices via a multiplexer orother interface controller. These gateway servers may be incommunication with a second subset of message distributionservers—channel servers—configured for collecting messages distributedwithin communication channels and for storing those messages within amessage repository database for indexing and archiving. In certainembodiments, the channel servers may be in communication with themultiplexer to provide various messages to client devices.

In certain embodiments, one or more of the multiplexers and/or themessage distribution servers may be geographically distributed, forexample, to service client devices located geographically proximate theone or more computing entities. However, in certain embodiments thevarious computing entities (including the multiplexers and/or themessage distribution servers) may be centrally-located.

Example System Architecture

Methods, apparatuses, and computer program products of the presentinvention may be embodied by any of a variety of devices. For example,the method, apparatus, and computer program product of an exampleembodiment may be embodied by a network device, such as a server orother network entity, configured to communicate with one or moredevices, such as one or more client devices. In some preferred andnon-limiting embodiments, the computing device may include fixedcomputing devices, such as a personal computer or a computerworkstation. Still further, example embodiments may be embodied by anyof a variety of mobile devices, such as a portable digital assistant(PDA), mobile phone, smartphone, laptop computer, tablet computer,wearable device, or any combination of the aforementioned devices.

FIGS. 1-2 illustrate example computing systems within which embodimentsof the present invention may operate. Users may access a group-basedcommunication platform 105 via a communication network 103 using clientdevices 101A-101N.

Communication network 103 may include any wired or wirelesscommunication network including, for example, a wired or wireless localarea network (LAN), personal area network (PAN), metropolitan areanetwork (MAN), wide area network (WAN), or the like, as well as anyhardware, software and/or firmware required to implement it (such as,e.g., network routers, etc.). For example, communication network 103 mayinclude a cellular telephone, an 802.11, 802.16, 802.20, and/or WiMaxnetwork. Further, the communication network 103 may include a publicnetwork, such as the Internet, a private network, such as an intranet,or combinations thereof, and may utilize a variety of networkingprotocols now available or later developed including, but not limited toTCP/IP based networking protocols. As discussed herein, the networkingprotocol is configured to enable data transmission via websocketcommunications. For instance, the networking protocol may be customizedto suit the needs of the group-based communication system. In someembodiments, the protocol is a custom protocol of JSON (JavaScriptObject Notation) objects sent via a websocket channel. In someembodiments, data may be transmitted via a plurality of protocols, suchas JSON over RPC (Remote Procedure Call), JSON over REST(REpresentational State Transfer)/HTTP, and the like.

In the illustrated embodiment, the group-based communication platform105 includes a plurality of message distribution servers 107A-107Naccessible via the communication network 103 via a multiplexer 109.Collectively, the message distribution servers 107A-107N are configuredfor receiving messages transmitted from one or more client devices101A-101N, storing the messages within database storage areas forindividual communication channels, and/or for transmitting messages toappropriate client devices 101A-101N via a multiplexer 109.

Similarly, the multiplexer 109 (or plurality of multiplexers 109) may beembodied as a computer or computers as known in the art. In theillustrated embodiment of FIG. 1, the multiplexer 109 provides forreceiving electronic data from various sources, including, but notlimited to the client devices 101A-101N (e.g., via websocketcommunications over the communications network 103) and/or the messagedistribution servers 107A-107N (e.g., via backend websocketcommunications, via push/pull data transmissions, and/or the like).Moreover, the multiplexer 109 of the illustrated embodiment is alsoconfigured to parse metadata provided as a portion of one or moreelectronic messages, and to direct incoming electronic messages to oneor more message distribution servers 107A-107N based at least in part onthe content of the metadata associated with the electronic messagesand/or to direct outbound electronic messages to one or more clientdevices 101A-101N based at least in part on the content of the metadataassociated with the electronic messages.

The client devices 101A-101N may be any computing device as definedabove. Electronic message data exchanged between the messagedistribution servers 107A-107N and the client devices 101A-101N via themultiplexer 109 may be provided in various forms and via variousmethods.

In some preferred and non-limiting embodiments, one or more of theclient devices 101A-101N are mobile devices, such as smartphones ortablets. The one or more client devices may execute an “app” to interactwith the message distribution servers 107A-107N and/or multiplexer 109.Such apps are typically designed to execute on mobile devices, such assmartphones or tablets. For example, an app may be provided thatexecutes on mobile device operating systems such as Apple Inc.'s iOS®,Google Inc.'s Android®, or Microsoft Inc.'s Windows 10 Mobile®. Theseplatforms typically provide frameworks that allow apps to communicatewith one another, and with particular hardware and software componentsof mobile devices. For example, the mobile operating systems named aboveeach provides frameworks for interacting with location servicescircuitry, wired and wireless network interfaces, user contacts, andother applications. Communication with hardware and software modulesexecuting outside of the app is typically provided via applicationprogramming interfaces (APIs) provided by the mobile device operatingsystem. Thus, via the app executing on the client devices 101A-101N,these client devices 101A-101N are configured for communicating with thegroup-based communication platform 105 via one or more websockets.

In some preferred and non-limiting embodiments, the client devices101A-101N may interact with the message distribution servers 107A-107Nand/or multiplexer 109 via a web browser. The client devices 101A-101Nmay also include various hardware or firmware designed to interact withthe message distribution servers 107A-107N and/or multiplexer 109.Again, via the browser of the client devices 101A-101N, the clientdevices 101A-101N are configured for communicating with the group-basedcommunication platform 105 via one or more websockets.

In some embodiments of an exemplary group-based communication platform105, a message or messaging communication may be sent from a clientdevice 101A-101N to a group-based communication platform 105. In variousimplementations, messages may be sent to the group-based communicationplatform 105 over communication network 103 directly by one of theclient devices 101A-101N. The messages may be sent to the group-basedcommunication platform 105 via an intermediary such as a message server,and/or the like. For example, a client device 101A-101N may be adesktop, a laptop, a tablet, a smartphone, and/or the like that isexecuting a client application (e.g., a group-based communication app).In one implementation, the message may include data such as a messageidentifier, sending user identifier, a group identifier, a group-basedcommunication channel identifier, message contents (e.g., text, emojis,images, links), attachments (e.g., files), message hierarchy data (e.g.,the message may be a reply to another message), third party metadata,and/or the like. In one embodiment, the client device 101A-101N mayprovide the following example message, substantially in the form of a(Secure) Hypertext Transfer Protocol (“HTTP(S)”) POST message includingeXtensible Markup Language (“XML”) formatted data, as provided below:

POST /authrequest.php HTTP/1.1 Host: www.server.com Content-Type:Application/XML Content-Length: 667 <?XML version = “1.0” encoding =“UTF-8”?> <auth_request>  <timestamp>2020-12-31 23 :59:59</timestamp> <user_accounts_details>   <user_account_credentials>   <user_name>ID_user_1</user_name>    <password>abc123</password>   //OPTIONAL <cookie>cookieID</cookie>    //OPTIONAL<digital_cert_link>www.mydigitalcertificate.com/  JohnDoeDaDoeDoe@gmailcom/mycertifcate.dc</digital_cert_link>    //OPTIONAL<digital_certificate>_DATA_</digital_certificate>  </user_account_credentials>  </user_accounts_details> <client_details>//iOS Client with App and Webkit    //it should benoted that although several client details    //sections are provided toshow example variants of client    //sources, further messages willinclude only on to save    //space   <client_IP>10.0.0.123</client_IP>  <user_agent_string>Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_1   like MacOS X)  AppleWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/ 11D201  Safari/9537.53</user_agent_string>  <client_product_type>iPhone6,1</client_product_type>  <client_serial_number>DNXXX1X1XXXX</client_serial_number>  <client_UDID>3XXXXXXXXXXXXXXXXXXXXXXXXD</   client_UDID>  <client_OS>iOS</client_OS>  <client_OS_version>7.1.1</client_OS_version>   <client_app_type>appwith webkit</client_app_type>  <app_installed_flag>true</app_installed_flag>  <app_name>MSM.app</app_name>   <app_version>1.0 </app_version>  <app_webkit_name>Mobile Safari</client_webkit_name>  <client_version>537.51.2</client_version>  </client_details> <client_details>//iOS Client with Webbrowser  <client_IP>10.0.0.123</client_IP>   <user_agent_string>Mozilla/5.0(iPhone; CPU iPhone OS 7_1_1   like Mac OS X)  AppleWebKit/537.51.2(KHTML, like Gecko) Version/7.0 Mobile/  11D201 Safari/9537.53</user_agent_string>  <client_product_type>iPhone6,1</client_product_type>  <client_serial_number>DNXXX1X1XXXX</client_serial_number>  <client_UDID>3XXXXXXXXXXXXXXXXXXXXXXXXD</   client_UDID>  <client_OS>iOS</client_OS>  <client_OS_version>7.1.1</client_OS_version>   <client_app_type>webbrowser</client_app_type>   <client_name>Mobile Safari</client_name>  <client_version>9537.53</client_version> </client_details><client_details>//Android Client with Webbrowser  <client_IP>10.0.0.123</client_IP>   <user_agent_string>Mozilla/5.0(Linux; U; Android 4.0.4; en-us;   Nexus S  Build/IMM76D)AppleWebKit/534.30 (KHTML, like Gecko) Version/  4.0 Mobile Safari/534.30</user_agent_string>   <client_product_type>NexusS</client_product_type>   <client_serial_number>YXXXXXXXX</client serialnumber>   <client_UDID>FXXXXXXXXX-XXXX-XXXX-XXXX- XXXXXXXXXXXXX</client_UDID>   <client_OS>Android</client_OS>  <client_OS_version>4.0.4</client_OS_version>   <client_app_type>webbrowser</client_app_type>   <client_name>Mobile Safari</client_name>  <client_version>534.30</client_version>  </client_details> <client_details>//Mac Desktop with Webbrowser  <client_IP>10.0.0.123</client_IP>   <user_agent_string>Mozilla/5.0(Macintosh; Intel Mac OS X   10_9_3)  AppleWebKit/537.75.14 (KHTML, likeGecko) Version/7.0.3  Safari/537.75.14</user_agent_string>  <client_product_type>MacPro5,1</client_product_type>  <client_serial_number>YXXXXXXXXZ</client_serial_number>  <client_UDID>FXXXXXXXXX-XXXX-XXXX-XXXX-  XXXXXXXXXXXXX</client_UDID>  <client_OS>Mac OS X</client_OS>  <client_OS_version>10.9.3</client_OS_version>   <client_app_type>webbrowser</client_app_type>   <client_name>Mobile Safari</client_name>  <client_version>537.75.14</client_version>  </client_details> <message>   <message_identifier>ID_message_10</message_identifier>  <team_identifier>ID_team_1</team_identifier>  <channel_identifier>ID_channel_1</channel_identifier>   <contents>Thatis an interesting invention. I have attached a copy   our patent  policy.</contents>   <attachments>patent_policy.pdf</attachments> </message> </auth_request>

In the illustrated embodiment, the group-based communication platform105 comprises a plurality of message distribution servers 107A-107Nconfigured to receive messages transmitted between a plurality of clientdevices 101A-101N within a channel identified by a channel identifierand/or a group identifier, and to facilitate dissemination of thosemessages among client devices 101A-101N that collectively form themembership of the communication channel.

In some embodiments, a correspondence tag, such as a group identifier,team identifier, and/or channel identifier as defined above may beassociated with the message. In some embodiments, the correspondence tagmay comprise or be embodied as a group-based communication channelidentifier as defined above that may be associated with the message. Inyet other embodiments, the correspondence tag may comprise or beembodied as a group-identifier as defined above that may be associatedwith the message.

In some embodiments, the correspondence tag may comprise or be embodiedas a sending user identifier as defined above that may be associatedwith the message. Moreover, the correspondence tag may comprise aplurality of identifiers in certain embodiments, such as any combinationof a group identifier a channel identifier and/or a sending useridentifier. In one implementation, the message may be parsed (e.g.,using PHP (Hypertext PreProcessor) commands) to determine a sending useridentifier of the user who sent the message.

In some embodiments, data indicating responses may be associated withthe message. For example, responses to the message by other users mayinclude reactions (e.g., selection of an emoji associated with themessage, selection of a “like” button associated with the message),clicking on a hyperlink embedded in the message, replying to the message(e.g., posting a message to the group-based communication channelinterface in response to the message), downloading a file associatedwith the message, sharing the message from one group-based communicationchannel to another group-based communication channel, pinning themessage, starring the message, and/or the like. In one implementation,data regarding responses to the message by other users may be includedwith the message, and the message may be parsed (e.g., using PHPcommands) to determine the responses. In another implementation, dataregarding responses to the message may be retrieved from a database. Forexample, data regarding responses to the message may be retrieved via aMySQL database command similar to the following:

SELECT messageResponses

FROM MSM_Message

WHERE messageID=ID_message_10.

For example, data regarding responses to the message may be used todetermine context for the message (e.g., a social score for the messagefrom the perspective of some user). In another example, data regardingresponses to the message may be analyzed to determine context regardingthe user (e.g., the user's expertise in a topic may be determined basedon the responses to the user's message regarding the topic).

In embodiments, attachments may be included with the message. If thereare attachments, files may be associated with the message. In oneimplementation, the message may be parsed (e.g., using PHP commands) todetermine file names of the attachments. For example, file contents maybe analyzed to determine context for the message (e.g., a patent policydocument may indicate that the message is associated with the topic“patents”).

In embodiments, a conversation primitive may be associated with themessage. In one implementation, a conversation primitive is an elementused to analyze, index, store, and/or the like messages. For example,the message may be analyzed by itself, and may form its own conversationprimitive. In another example, the message may be analyzed along withother messages that make up a conversation, and the messages that makeup the conversation may form a conversation primitive. In oneimplementation, the conversation primitive may be determined as themessage, a specified number (e.g., two) of preceding messages and aspecified number (e.g., two) of following messages. In anotherimplementation, the conversation primitive may be determined based onanalysis of topics discussed in the message and other messages (e.g., inthe channel) and/or proximity (e.g., message send order proximity,message send time proximity) of these messages.

In embodiments, various metadata, determined as described above, and/orthe contents of the message may be used to index the message (e.g.,using the conversation primitive) and/or to facilitate various facets ofsearching (i.e., search queries that return results from the messagedistribution servers 107). Metadata associated with the message may bedetermined and the message may be indexed in the message distributionservers 107A-107N. In one embodiment, the message may be indexed suchthat a company's or a group's messages are indexed separately (e.g., ina separate index associated with the group and/or company that is notshared with other groups and/or companies). In one implementation,messages may be indexed at a separate distributed repository (e.g., tofacilitate data isolation for security purposes). If there areattachments associated with the message, file contents of the associatedfiles may be used to index such files in the message distributionservers 107A-107N to facilitate searching. In one embodiment, the filesmay be indexed such that a company's or a group's files are indexed at aseparate distributed repository.

Examples of electronic information exchange among one or more clientdevices 101A-101N and the group-based communication platform 105 aredescribed below with reference to FIGS. 1-2.

As shown in FIGS. 1-2, the group-based communication platform 105enables individual client devices 101A-101N to exchange various messageswith one another. To exchange such messages, individual client devices101A-101N transmit messages (e.g., text-based messages, files, videoand/or audio streams, and/or the like) to an interface (e.g.,multiplexer 109) via a communication protocol (e.g., via a websocket, anon-RTM messaging protocol, and/or the like). Those messages areultimately provided to one or more message distribution servers107A-107N, which indexes the messages and distributes those messages tothe intended recipients (e.g., client devices 101A-101N) of the message.The distributed messages are provided to the recipient client devices101A-101N via the multiplexer, which maintains single websocketconnections with individual recipient client devices 101A-101N of themessage, and maintains one or more communication connections with thevarious message distribution servers 107A-107N (e.g., websocketconnections, as shown in FIG. 1, or non-websocket connections, as shownin FIG. 2).

According to embodiments of FIGS. 1-2, the client devices 101A-101N areconfigured to display the received message in contextually-relevant userinterfaces available to the user of the client device 101A-101N. Forexample, messages transmitted from a first client device 101 as a partof a group-based communication channel are displayed in a user interfacedisplay window on client devices 101A-101N associated with other membersof the group-based communication channel. As discussed herein, themessages are transmitted with correspondence tags usable by therecipient client devices 101A-101N to display those messages withinappropriate user display elements. Those correspondence tags maycomprise team identifiers, group identifiers, and/or channel identifiersusable by a client device to direct those messages to appropriatedisplay windows. Moreover, the correspondence tags may be usable byvarious ones of the message distribution servers 107A-107N to directthose messages to appropriate recipient client devices 101A-101N and/orto index and store those messages within appropriate database instances.To distribute those messages to individual client devices 101A-101N, themessages are transmitted from the message distribution servers 107A-107Nto the multiplexer 109, which compiles all messages destined forrespective ones of the client devices 101A-101N, and transmits all ofthose messages to the client devices 101A-101N over a common websocketconnection (each client device 101A-101N being connected with themultiplexer over a respective websocket connection), regardless of thecommunication channel in which the message is exchanged. However, itshould be understood that in certain embodiments, a plurality ofwebsocket connections may be utilized for transmitting data to theclient device. For example, a first websocket connection may be utilizedfor transmitting compiled messages (e.g., messages exchanged within aplurality of communication channels) to the client device, and a secondwebsocket connection may be utilized for transmitting other data types(e.g., particular documents shared among a plurality of client devices,and/or the like).

Once the messages are received at the client devices 101A-101N, softwareinstances executing on the individual client devices 101A-101N directthe messages to contextually appropriate display windows correspondingto the communication channels in which the messages are exchanged. Forexample, the client devices 101A-101N may be configured to share allmessages with all display windows, and each of those display windows mayoperate with respective correspondence identifiers to filter and displayonly those messages that are contextually relevant to the communicationchannel displayed within the respective display window. For example,each display window may have associated correspondence identifiersidentifying the communication channel corresponding to the displaywindow. As messages are received at each display window instance, theclient device 101 compares the correspondence tags of the individualmessages against the correspondence identifiers for the particulardisplay window to filter all those messages not relating tocorrespondence identifier of the particular display window. The messagesmay further comprise additional metadata, such as sending useridentifiers, time stamps, and/or the like to enable the client device101 to display messages in an appropriate order (e.g., the order inwhich they are received) and/or with other data that may be utilized toprovide context for the messages.

In other embodiments, all messages transmitted to a particular clientdevice 101 are received via a single display window (discussed herein asa main window or a parent window, used interchangeably), which isconfigured to parse the messages received by the client device 101 andto provide those messages to contextually relevant display windows(discussed herein as child windows). Thus, individual display windowsonly receive messages that are contextually relevant for the particulardisplay window.

Example Apparatuses Utilized with Various Embodiments

Each message distribution server 107 may be embodied by one or morecomputing systems, such as apparatus 200 shown in FIG. 3. The apparatus200 may include processor 202, memory 204, input/output circuitry 206,communications circuitry 208, and message amplifier circuitry 210. Theapparatus 200 may be configured to execute the operations describedherein with respect to FIGS. 1-7. Although these components 202-210 aredescribed with respect to functional limitations, it should beunderstood that the particular implementations necessarily include theuse of particular hardware. It should also be understood that certain ofthese components 202-210 may include similar or common hardware. Forexample, two sets of circuitries may both leverage use of the sameprocessor, network interface, storage medium, or the like to performtheir associated functions, such that duplicate hardware is not requiredfor each set of circuitries.

In some embodiments, the processor 202 (and/or co-processor or any otherprocessing circuitry assisting or otherwise associated with theprocessor) may be in communication with the memory 204 via a bus forpassing information among components of the apparatus. The memory 204 isnon-transitory and may include, for example, one or more volatile and/ornon-volatile memories. In other words, for example, the memory 204 maybe an electronic storage device (e.g., a computer-readable storagemedium). The memory 204 may be configured to store information, data,content, applications, instructions, or the like for enabling theapparatus to carry out various functions in accordance with exampleembodiments of the present invention.

The processor 202 may be embodied in a number of different ways and may,for example, include one or more processing devices configured toperform independently. In some preferred and non-limiting embodiments,the processor 202 may include one or more processors configured intandem via a bus to enable independent execution of instructions,pipelining, and/or multithreading. The use of the term “processingcircuitry” may be understood to include a single core processor, amulti-core processor, multiple processors internal to the apparatus,and/or remote or “cloud” processors.

In some preferred and non-limiting embodiments, the processor 202 may beconfigured to execute instructions stored in the memory 204 or otherwiseaccessible to the processor 202. In some preferred and non-limitingembodiments, the processor 202 may be configured to execute hard-codedfunctionalities. As such, whether configured by hardware or softwaremethods, or by a combination thereof, the processor 202 may represent anentity (e.g., physically embodied in circuitry) capable of performingoperations according to an embodiment of the present invention whileconfigured accordingly. Alternatively, as another example, when theprocessor 202 is embodied as an executor of software instructions, theinstructions may specifically configure the processor 202 to perform thealgorithms and/or operations described herein when the instructions areexecuted.

As just one example, the processor 202 may be configured to maintain oneor more communication channels connecting a plurality of client devices101A-101N to enable message sharing therebetween. The processor 202ensures that messages intended for exchange between the client devices101A-101N within the particular communication channel are properlydisseminated to those client devices 101A-101N for display withinrespective display windows provided via the client devices 101A-101N.

Moreover, the processor 202 may be configured to synchronize messagesexchanged on a particular communication channel with a database forstorage and/or indexing of messages therein. In certain embodiments, theprocessor 202 may provide stored and/or indexed messages to themultiplexer 109 for dissemination to client devices 101A-101N.

In some embodiments, the apparatus 200 may include input/outputcircuitry 206 that may, in turn, be in communication with processor 202to provide output to the user and, in some embodiments, to receive anindication of a user input. The input/output circuitry 206 may comprisea user interface and may include a display, and may comprise a web userinterface, a mobile application, a client device, a kiosk, or the like.In some embodiments, the input/output circuitry 206 may also include akeyboard, a mouse, a joystick, a touch screen, touch areas, soft keys, amicrophone, a speaker, or other input/output mechanisms. The processorand/or user interface circuitry comprising the processor may beconfigured to control one or more functions of one or more userinterface elements through computer program instructions (e.g., softwareand/or firmware) stored on a memory accessible to the processor (e.g.,memory 204, and/or the like).

The communications circuitry 208 may be any means such as a device orcircuitry embodied in either hardware or a combination of hardware andsoftware that is configured to receive and/or transmit data from/to anetwork and/or any other device, circuitry, or module in communicationwith the apparatus 200. In this regard, the communications circuitry 208may include, for example, a network interface for enablingcommunications with a wired or wireless communication network. Forexample, the communications circuitry 208 may include one or morenetwork interface cards, antennae, buses, switches, routers, modems, andsupporting hardware and/or software, or any other device suitable forenabling communications via a network. Additionally or alternatively,the communications circuitry 208 may include the circuitry forinteracting with the antenna/antennae to cause transmission of signalsvia the antenna/antennae or to handle receipt of signals received viathe antenna/antennae.

Message amplifier circuitry 210 includes hardware configured to copy andamplify electronic messages and associated metadata received from one ormore client devices 101A-101N to other client devices 101A-101N based ondatabase shard(s). The message amplifier circuitry 210 may utilizeprocessing circuitry, such as the processor 202, to perform theseactions. However, it should also be appreciated that, in someembodiments, the message amplifier circuitry 210 may include a separateprocessor, specially configured Field Programmable Gate Array (FPGA), orApplication Specific Integrated Circuit (ASIC) for performing thefunctions described herein. The message amplifier circuitry 210 may beimplemented using hardware components of the apparatus configured byeither hardware or software for implementing these planned functions.

It is also noted that all or some of the information discussed hereincan be based on data that is received, generated and/or maintained byone or more components of apparatus 200. In some embodiments, one ormore external systems (such as a remote cloud computing and/or datastorage system) may also be leveraged to provide at least some of thefunctionality discussed herein.

In the illustrated embodiment of FIG. 4, the multiplexer 109 is embodiedby one or more computing systems encompassing apparatus 300. Theillustrated apparatus 300 includes processor 301, memory 303,input/output circuitry 305, and communications circuitry 307. Theapparatus 300 may be configured to execute the operations describedherein with respect to FIGS. 1-7. Although these components 301-307 aredescribed with respect to functional limitations, it should beunderstood that the particular implementations necessarily include theuse of particular hardware. It should also be understood that certain ofthese components 301-307 may include similar or common hardware. Forexample, two sets of circuitries may both leverage use of the sameprocessor, network interface, storage medium, or the like to performtheir associated functions, such that duplicate hardware is not requiredfor each set of circuitries.

In some embodiments, the processor 301 (and/or co-processor or any otherprocessing circuitry assisting or otherwise associated with theprocessor) may be in communication with the memory 303 via a bus forpassing information among components of the apparatus. The memory 303 isnon-transitory and may include, for example, one or more volatile and/ornon-volatile memories. In other words, for example, the memory 303 maybe an electronic storage device (e.g., a computer-readable storagemedium). The memory 303 may be configured to store information, data,content, applications, instructions, or the like for enabling theapparatus 300 to carry out various functions in accordance with exampleembodiments of the present invention. For example, the memory 303 may beconfigured to cache messages exchanged on one or more group-basedcommunication channels, such that the processor 301 may provide variousmessages to client devices (e.g., on an as needed or as requestedbasis).

The processor 301 may be embodied in a number of different ways and may,for example, include one or more processing devices configured toperform independently. In some preferred and non-limiting embodiments,the processor 301 may include one or more processors configured intandem via a bus to enable independent execution of instructions,pipelining, and/or multithreading.

In some preferred and non-limiting embodiments, the processor 301 may beconfigured to execute instructions stored in the memory 303 or otherwiseaccessible to the processor 301. In some preferred and non-limitingembodiments, the processor 301 may be configured to execute hard-codedfunctionalities. As such, whether configured by hardware or softwaremethods, or by a combination thereof, the processor 301 may represent anentity (e.g., physically embodied in circuitry) capable of performingoperations according to an embodiment of the present invention whileconfigured accordingly. Alternatively, as another example, when theprocessor 301 is embodied as an executor of software instructions, theinstructions may specifically configure the processor 301 to perform thealgorithms and/or operations described herein when the instructions areexecuted.

In some embodiments, the apparatus 300 may include input/outputcircuitry 305 that may, in turn, be in communication with processor 301to provide output to the user and, in some embodiments, to receive anindication of a user input. The input/output circuitry 305 may comprisea user interface and may include a display, and may comprise a web userinterface, a mobile application, a client device, a kiosk, or the like.In some embodiments, the input/output circuitry 305 may also include akeyboard, a mouse, a joystick, a touch screen, touch areas, soft keys, amicrophone, a speaker, or other input/output mechanisms.

The communications circuitry 307 may be any means such as a device orcircuitry embodied in either hardware or a combination of hardware andsoftware that is configured to receive and/or transmit data from/to anetwork and/or any other device, circuitry, or module in communicationwith the apparatus 300. In this regard, the communications circuitry 307may include, for example, a network interface for enablingcommunications with a wired or wireless communication network. Forexample, the communications circuitry 307 may include one or morenetwork interface cards, antennae, buses, switches, routers, modems, andsupporting hardware and/or software, or any other device suitable forenabling communications via a network. Additionally or alternatively,the communications circuitry 307 may include the circuitry forinteracting with the antenna/antennae to cause transmission of signalsvia the antenna/antennae or to handle receipt of signals received viathe antenna/antennae.

It is also noted that all or some of the information discussed hereincan be based on data that is received, generated and/or maintained byone or more components of apparatus 300. In some embodiments, one ormore external systems (such as a remote cloud computing and/or datastorage system) may also be leveraged to provide at least some of thefunctionality discussed herein.

Moreover, although the multiplexer 109 is shown within the bounds of thegroup-based communication platform 105, it should be understood that themultiplexer 109 may be embodied as an edge-based computing device incommunication with aspects of the group-based communication platform 105via a communication network 103. Such embodiments may comprise aplurality of multiplexers 109 that are geographically distributed, andsuch multiplexers 109 may be configured for communicating with clientdevices 101A-101N within a geographic range proximate a respectivemultiplexer 109.

The term “circuitry” should be understood broadly to include hardwareand, in some embodiments, software for configuring the hardware. Withrespect to components of each apparatus 200, 300, the term “circuitry”as used herein should therefore be understood to include particularhardware configured to perform the functions associated with theparticular circuitry as described herein. For example, in someembodiments, “circuitry” may include processing circuitry, storagemedia, network interfaces, input/output devices, and the like. In someembodiments, other elements of the apparatus 200 may provide orsupplement the functionality of particular circuitry. For example, theprocessor 202 may provide processing functionality, the memory 204 mayprovide storage functionality, the communications circuitry 208 mayprovide network interface functionality, and the like. Similarly, otherelements of the apparatus 300 may provide or supplement thefunctionality of particular circuitry. For example, the processor 301may provide processing functionality, the memory 303 may provide storagefunctionality, the communications circuitry 307 may provide networkinterface functionality, and the like.

As will be appreciated, any such computer program instructions and/orother type of code may be loaded onto a computer, processor or otherprogrammable apparatus's circuitry to produce a machine, such that thecomputer, processor or other programmable circuitry that execute thecode on the machine creates the means for implementing variousfunctions, including those described herein.

As described above and as will be appreciated based on this disclosure,embodiments of the present invention may be configured as methods,mobile devices, backend network devices, and the like. Accordingly,embodiments may comprise various means including entirely of hardware orany combination of software and hardware. Furthermore, embodiments maytake the form of a computer program product on at least onenon-transitory computer-readable storage medium having computer-readableprogram instructions (e.g., computer software) embodied in the storagemedium. Any suitable computer-readable storage medium may be utilizedincluding non-transitory hard disks, CD-ROMs, flash memory, opticalstorage devices, or magnetic storage devices.

Moreover, although not shown, various embodiments of a group-basedcommunication platform may comprise one or more databases configured forstoring and/or indexing messages exchanged within various group-basedcommunication channels.

Example Data Flows

FIGS. 6-7 are flowcharts illustrating the functionality of thegroup-based communication platform 105 (specifically with reference tothe functionality of the multiplexer 109) and individual client devices101A-101N, respectively. As mentioned herein, various embodiments enablethe group-based communication platform 105 to provide a plurality ofmessages to individual client devices 101A-101N via single websocketconnections (a single websocket connection per client device 101),regardless of the communication channel in which the messages areexchanged. Upon receipt of the messages, the client devices 101A-101Nascertain contextual information relating to each individual messagesuch that those messages are displayed in appropriate display windowscorresponding to the communication channel in which the messages areexchanged.

Multiplexer Operation

Beginning with a discussion of FIG. 6, which illustrates variousfunctionalities of the multiplexer 109 of the group-based communicationplatform 105, various embodiments are configured to begin messagedistribution functionalities by maintaining a websocket connectionestablished between the multiplexer 109 and individual client devices101A-101N, as shown at Block 601.

The websocket connection may enable real-time transmission of messagesfrom the multiplexer 109 to the individual client device 101 (and incertain embodiments, the websocket connection may be configured toenable the client device 101 to transmit messages to the multiplexer 109over the same connection). From the perspective of the multiplexer 109,each websocket connection is associated with a respective client device101, and accordingly the multiplexer 109 may be configured to store dataindicative of the identity of the client device 101 associated with eachindividual websocket connection. FIGS. 1-2 schematically illustrate thefunctionality of the multiplexer 109 in transmitting messages via abackend websocket connection (illustrated as thick-lined arrows) toclient devices 101A-101N via the communication network 103.

The multiplexer 109 may be configured to maintain a websocket connectionestablished with a client device 101 each time the client device 101logs-in or otherwise becomes available for message exchange with thegroup-based communication platform 105 (e.g., upon opening an app on theclient device 101 associated with the group-based communication platform105). As discussed herein, the group-based communication platform 105 isconfigured to store messages destined for a particular client device 101while the client device 101 is disconnected from the group-basedcommunication platform 105 until the client device 101 becomes availableto receive messages. Accordingly, the multiplexer 109 may be configuredto monitor the status of individual client devices 101A-101N and theirassociated websocket connections to ascertain when and/or whetherparticular client devices 101A-101N are available to receive messages.The multiplexer 109 may be configured to provide such statusinformation/data to other components of the group-based communicationplatform 105, such as message distribution servers 107A-107N. Indeed,message distribution servers 107A-107N may be configured to disseminatestatus messages to client devices 101A-101N based on user (clientdevice) status data generated by the multiplexer 109 or other interfaceaspect of the group-based communication platform 105. As discussedherein, the message distribution servers 107A-107N may be configured tostore messages exchanged within individual communication channels andaccordingly the message distribution servers 107A-107N may be configuredto provide messages to be disseminated to individual client devices101A-101N to the multiplexer 109 only during time periods in which theindividual client devices 101A-101N are available to receive suchmessages.

Upon initialization of the websocket connection with the client device101, the multiplexer 109 may be configured to attribute particularcommunication channel memberships with the client device 101 to enabletransmission of messages exchanged within the particular correspondencechannels to the client device 101. As discussed herein, the clientdevice 101 may provide an authentication token request to themultiplexer 109 identifying a plurality of communication channels to beattributed to the client device 101. In such embodiments, themultiplexer 109 may generate an authentication token in response,identifying all those communication channels to be attributed to theclient device 101, thereby enabling transmission of messages exchangedwithin those communication channels to the client device 101.

In other embodiments, client devices 101A-101N may be configured totransmit a plurality of join request messages to the multiplexer 109,each join request message corresponding to a respective requestedcommunication channel membership. In such embodiments, the multiplexer109 may be configured to provide individual authentication tokens inresponse to the plurality of join requests, thereby enablingtransmission of messages exchanged within the joined memberships to theclient device 101.

During instances in which a client device 101 is available to receivemessages, the multiplexer 109 receives messages for the client device101 from the message distribution servers 107A-107N as shown at Block602. The multiplexer 109 may be configured to receive messages from themessage distribution servers 107A-107N via any of a variety of messagetransmission protocols. For example, the message distribution servers107A-107N may be configured to establish one or more backend websocketconnections with the multiplexer 109 as shown in the schematicillustration of FIG. 1. In such embodiments, the message distributionservers 107A-107N establish a single websocket connection with themultiplexer 109 for each client device-specific membership in variouscommunication channels. As a specific example, if a particular user(client device 101) is a member of 3 different communication channels,such that the client device 101 receives messages exchanged in each ofthose 3 communication channels, the message distribution servers107A-107N establish 3 backend websocket connections with the multiplexer109 corresponding to that single client device 101. In such embodiments,the number of websocket connections utilized for disseminating messagesto an individual client device 101 is equal to one more than the totalnumber of communication channel memberships for the client device 101 (asingle websocket connection between the multiplexer 109 and the clientdevice 101, and a single backend websocket connection corresponding toeach communication channel membership is established between themultiplexer 109 and the message distribution servers 107A-107N).

In other embodiments, only a single websocket connection is utilized foreach client device 101 for disseminating messages, as shownschematically in FIG. 2. The websocket connection is established betweenthe multiplexer 109 and the client device 101 (as discussed in referenceto Block 601 of FIG. 6), and the multiplexer 109 receives messages fromthe message distribution servers 107A-107N via other communicationprotocols that enable RTM message transmissions or non-RTM messagetransmissions.

In either embodiment, the group-based communication platform 105 may beconfigured to store a rolling buffer of messages destined fortransmission to the client device 101. For example, the most recent5-minutes, most recent 50 messages, and/or the like may be stored in abuffer corresponding to a particular websocket connection (e.g., aparticular backend websocket connection). The rolling-buffer may beutilized to quickly, and with minimal bandwidth, update messagesdestined for transmission to the client device 101 in instances in whicha websocket disconnects and reconnects prior to the expiration of therolling buffer. In embodiments in which a single websocket connection isutilized for message transmissions to the client device 101, themultiplexer 109 (and/or an associated database) may store a singlerolling buffer for each connected client device 101. In embodiments inwhich the number of websocket connections is equal to one more than thetotal number of correspondence memberships for each client device 101(e.g., including backend websocket connections and websocket connectionswith the client device 101), the message distribution servers 107A-107Nmay be configured to store rolling-buffers for each websocket connectionwith the multiplexer 109. The multiplexer 109 may additionally beconfigured to store another rolling-buffer corresponding to thewebsocket connection with the client device 101. Accordingly, thoseembodiments utilizing only a single websocket connection fortransmission of messages to client devices 101 utilizes a significantlysmaller amount of storage for rolling-buffers than embodiments utilizinga plurality of websocket connections for message distribution toindividual client devices 101A-101N.

With reference again to FIG. 6, upon receipt of messages destined fordistribution to an individual client device 101, the multiplexer 109receives messages destined for a single client device 101 withcorresponding correspondence tags identifying the communication channelassociated with the individual message, as shown at Block 603. Incertain embodiments, the messages may be transmitted from the messagedistribution servers 107A-107N in association with the correspondencetags, or the multiplexer 109 may be configured to generate thecorrespondence tags based on characteristics of how the messages areprovided to the multiplexer 109. For example, the multiplexer 109 may beconfigured to generate the correspondence tags based at least in part onthe identity of a particular backend websocket utilized to transmit themessage from the message distribution servers 107A-107N to themultiplexer 109.

The multiplexer 109 may be configured to relay messages to respectiveclient devices 101A-101N in real-time, upon receipt of those messagesfrom the message distribution servers 107A-107N. Accordingly, uponreceipt of individual messages, the multiplexer 109 is configured totransmit those messages to respective client devices 101A-101N viarespective websocket connections, as indicated at Block 604.

In other embodiments, the multiplexer 109 may be configured for periodicmessage transmission to individual client devices 101A-101N, such thatmessages are not transmitted in real-time. For example, messages may betransmitted from the multiplexer 109 in response to the occurrence of atrigger event and/or at defined time intervals. In such embodiments, themultiplexer 109 may be configured to maintain the websocket connectionwith client devices 101A-101N only periodically, such that the websocketconnection is only open with a client device 101 while messages arebeing transmitted to the client device 101.

As a specific example, a client device 101 may initiate a websocketconnection with the multiplexer 109 in response to detection of atrigger event (e.g., an elapsed time, a user input and/or the like, suchthat the multiplexer 109 transmits messages to the client device 101while the websocket connection remains open. As yet another example, theclient device 101 may be configured to initiate and maintain an openwebsocket connection with the multiplexer 109 for established timeperiods, according to a defined schedule. Specifically, the clientdevice 101 may be configured to maintain a websocket connection openwith the multiplexer 109 for a single, continuous minute (or anothertime period), and then to close the websocket connection and to maintainthe closed websocket for a continuous 9 minute period (or another timeperiod) before reopening the websocket connection. Thus, the clientdevice 101 may be configured to maintain the websocket connection asopen for a small percentage of total time (e.g., 10% of time). In suchembodiments, the multiplexer 109 may be configured to transmit messagesin real-time while the websocket connection remains open, and to storemessages received during the period of time that the websocketconnection remains closed, and to transmit the messages uponreinitialization of the websocket connection with the client device.

With reference to the message transmission processes represented byBlock 604, various messages transmitted by the multiplexer 109 may bedestined for display within a plurality of display windows once receivedby a client device 101. The multiplexer 109 may thus be configured fortransmitting such messages with a plurality of correspondence tags toenable those messages to be displayed within a plurality of displaywindows once received by a client device 101 (e.g., each of theplurality of display windows being associated with a particularcommunication channel identified by the correspondence tags transmittedwith the message). Accordingly, because these messages are transmittedover a single websocket connection and then disseminated to appropriatedisplay windows, the total number of messages transmitted to the clientdevice 101 from the group-based communication platform 105 may beminimized. Whereas duplicate messages may be transmitted to the clientdevice 101 in instances in which each communication channel membershipis supported by a single, corresponding websocket, a single message maybe transmitted to the client device 101 and then disseminated to aplurality of display windows once received at the client device 101.

Client Device Operation

FIG. 7 provides a flowchart illustration of various steps performed bythe client device 101 for displaying messages that have been receivedvia the websocket connection with the multiplexer 109. Block 701illustrates the client device's processes for initializing the websocketconnection with the multiplexer 109. As discussed herein, the clientdevice 101 may be configured to initialize the websocket connection withthe multiplexer 109 upon initialization of the client device 101 (e.g.,initialization of an app associated with the group-based communicationplatform 105). In other embodiments, the client device 101 may beconfigured to initialize a websocket connection with the multiplexer 109according to a defined schedule (e.g., such that the websocketconnection is open for a portion of the time (e.g., 10%) while theclient device 101 is active with the group-based communication platform105).

Moreover, as mentioned above, each client device 101 may have a singleassociated websocket connection with the multiplexer 109. In otherembodiments, the client device 101 may be configured to initialize andmaintain a plurality of websocket connections with the multiplexer 109(or a plurality of multiplexers), however the total number of websocketconnections that the client device 101 maintains simultaneously may besmaller than the total number of communication channel membershipsmaintained by the client device 101. In other words, each websocketconnection maintained by the client device 101 may be configured fortransmitting messages exchanged within a plurality of communicationchannels and/or between members of a plurality of communication groups.

As a part of the initialization process for individual websockets, theclient device 101 may be configured to provide data to the multiplexer109 indicating which communication channel memberships should beutilized for transmission of messages to the client device 101. Incertain embodiments, the client device 101 may be configured to generateand transmit an authentication token request to the multiplexer 109(e.g., via the websocket connection), wherein the authentication tokenrequest identifies each of the communication channel memberships to beattributed to the client device 101. The authentication token may betransmitted as a single message or a plurality of messages. As discussedherein, the multiplexer 109 may, in response to the authentication tokenrequest, generate a corresponding authentication token to identify thosecommunication channel memberships associated with the client device 101,such that appropriate messages corresponding to each of thecommunication channel memberships are provided to the client device 101.

As yet another example, upon initialization of the websocket connectionbetween the client device 101 and the multiplexer 109, the client device101 may generate and transmit a plurality of join requests eachcorresponding to a particular communication channel to request thatmessages exchanged within the communication channel are transmitted tothe requesting client device 101.

With reference again to FIG. 7, the client device 101 receives messagestransmitted via the websocket connection from the multiplexer 109, asindicated at Block 702. Each message has associated correspondence tagsidentifying communication channels and/or groups in which the message isexchanged. For example, a particular message may be transmitted with acorrespondence tag indicating that the message was shared within adirect message channel between the user associated with the clientdevice 101 and a single other user. As yet another example, a presencemessage (indicating that a particular user has connected or disconnectedfrom the group-based communication platform 105) may be transmitted withcorrespondence tags indicating that the message should be displayedwithin all communication channels (e.g., group-based communicationchannels and/or direct message communication channels) in which the useris active. The presence message may thus be transmitted with a pluralityof correspondence tags in instances in which the user is active within aplurality of communication channels, and therefore client devices101A-101N receiving the presence message may be configured to displaythe presence message within a plurality of display windows, as indicatedby a plurality of correspondence tags transmitted with the message. Asyet another example, the correspondence tags associated with a messagemay indicate that the message should be disseminated within a pluralityof channels corresponding to a particular group.

To ensure messages are displayed in appropriate display windows at theclient device 101, the client device 101 disseminates received messagesto a plurality of display windows (e.g., including the main/parentwindow and/or a plurality of child windows), as indicated at Block 603.In certain embodiments, all display windows operable via the clientdevice 101 receive or otherwise have access to all messages transmittedto the client device 101. However, each display window operates with anassociated display filter based on associated correspondence identifierssuch that only messages shared within the communication channelrepresented within the display window are displayed therein. Accordingto these embodiments, each display window is configured to remaincontinuously updated as to the connection status of the client device101 with the multiplexer 109 (e.g., such that each display window isconfigured to display data indicating the connection status of theclient device 101) based at least in part on messages received via thewebsocket connection. Moreover, messages to be displayed within aparticular display window are displayed in accordance with additionalmetadata transmitted with the message, such that messages are displayedwith data indicative of the user transmitting a particular message, aswell as data illustrating whether the message is a stand-alone messageor is provided in response to another message already displayed withinthe display window.

In other embodiments, the client device 101 may operate with a parentdisplay window 501 and a plurality of child display windows 502-503N, asrepresented by FIG. 5. Messages transmitted via the websocket connectionwith the multiplexer 109 may be initially received at the parent displaywindow 501 and the parent display window 501 may be configured todisseminate messages to child display windows 502-503N as necessary.Thus, the parent display window 501 may be configured to execute one ormore message distribution algorithms (e.g., in real time) as messagesare received at the parent display window 501. In certain embodiments,the parent display window 501 is configured to parse messages receivedby the client device 101 to ascertain the appropriate display window foreach message. The parent display window 501 thereafter provides thosemessages to respective display windows for display (or displays thosemessages within a pane of the parent display window, as appropriate). Asshown in the example of FIG. 5, the parent display window 501 providesmessages exchanged as a part of a video discussion to a first childdisplay window 502, and provides additional message data (e.g.,post-based message data) to one or more text-based messaging windows503A-503N.

In the latter embodiment, each child display window 502-503N does nothave direct messaging communication with the group-based communicationplatform 105 via the websocket connection, and therefore the childdisplay windows 502-503N only receive connection status data from theparent display window 501. Thus, the parent display window 501 may beconfigured to periodically generate and provide connection status datato each of the child display windows 502-503N, indicative of the currentstatus of the connection between the client device 101 and themultiplexer 109. The parent display window thereby virtually duplicatesstatus messages indicative of the websocket connection status that areotherwise directly provided to the parent display window.

Moreover, for messages destined for display in a plurality of childdisplay windows 502-503N (and/or destined for display via the parentdisplay window 501 and at least one child display window 502-503N), theparent display window 501 may be configured to provide these messages toall of the appropriate display windows for display therein.

With reference again to FIG. 7, the client device 101 is configured todisplay the received messages within respective display windows (andwithin appropriate display panes of those display windows, ifapplicable), as indicated at Block 704. The messages may be displayedwith relevant contextual information, such as the author/transmittinguser that provides the message, whether the message is a reply to anexisting message (reply messages may be displayed as visually nestedbelow and/or indented relative to other messages), timestamp dataindicating when the message was transmitted, and/or the like.

CONCLUSION

Many modifications and other embodiments will come to mind to oneskilled in the art to which this disclosure pertains having the benefitof the teachings presented in the foregoing descriptions and theassociated drawings. Therefore, it is to be understood that thedisclosure is not to be limited to the specific embodiments disclosedand that modifications and other embodiments are intended to be includedwithin the scope of the appended claims. Although specific terms areemployed herein, they are used in a generic and descriptive sense onlyand not for purposes of limitation.

That which is claimed:
 1. A message distribution system fordisseminating messages to client devices in association with acommunication platform, the system comprising: one or more messagedistribution servers configured for directing messages shared withincommunication channels to client devices; and at least one multiplexerconfigured to: maintain a websocket connection with a client device ofthe plurality of client devices; maintain a plurality of backendwebsocket connections with the one or more message distribution servers,wherein each of the plurality of backend websocket connectionscorresponds to a communication channel; and transmit a plurality ofmessages shared within respective communication channels from the one ormore message distribution servers to the client device via the websocketconnection, wherein each of the plurality of messages comprises acorrespondence tag identifying a respective communication channel fordisplay of the respective message on the client device within a displaywindow corresponding to the communication channel, wherein each displaywindow is displayed within a communication channel interface displayedvia a display device of the client device.
 2. The message distributionsystem of claim 1, wherein a message of the plurality of messagescomprises a plurality of correspondence tags identifying a plurality ofcommunication channels for display of the respective message.
 3. Themessage distribution system of claim 1, wherein the multiplexer isfurther configured to: receive an authentication token from the clientdevice identifying a plurality of communication channels subscribed toby the client device; and transmit a plurality of messages shared withinsubscribed communication channels from the one or more messagedistribution servers to the client device via the websocket connection.4. The message distribution system of claim 1, wherein the multiplexeris further configured to: receive a plurality of join request messagesfrom the client device, wherein each join request identifies acommunication channel to be joined by the client device; and transmit aplurality of messages shared within the joined communication channelsfrom the one or more message distribution servers to the client devicevia the websocket connection.
 5. The message distribution system ofclaim 1, wherein maintaining the websocket connection comprises:initializing the websocket connection in response to a first triggerevent to enable transmission of messages to the client device; closingthe websocket connection in response to a second trigger event; andstoring a plurality of messages in a buffer memory while the websocketconnection is closed, such that the plurality of messages stored in thebuffer memory are transmitted to the client device upon initializationof the websocket connection.
 6. The message distribution system of claim5, wherein the first trigger event is selected from: a predeterminedtime or receipt of a query from the client device.
 7. A method formultiplexing messages disseminated to client devices withincommunication channels in association with a communication platform,platform, the method comprising: maintaining a websocket connection witha client device in association with a communication platform;maintaining a plurality of backend websocket connections with one ormore message distribution servers, wherein the plurality of backendwebsocket connections each correspond to a communication channel; andtransmitting a plurality of messages shared within respectivecommunication channels from the one or more message distribution serversto the client device via the websocket connection, wherein each of theplurality of messages comprises a correspondence tag identifying arespective communication channel for display of the respective messageon the client device within a display window corresponding to thecommunication channel, wherein each display window is displayed within acommunication channel interface displayed via a display device of theclient device.
 8. The method of claim 7, wherein a message of theplurality of messages comprises a plurality of correspondence tagsidentifying a plurality of communication channels for display of therespective message.
 9. The method of claim 7, further comprising:receiving an authentication token from the client device identifying aplurality of communication channels subscribed to by the client device;and transmitting a plurality of messages shared within subscribedcommunication channels from the one or more message distribution serversto the client device via the websocket connection.
 10. The method ofclaim 7, further comprising: receiving a plurality of join requestmessages from the client device, wherein each join request identifies acommunication channel to be joined by the client device; andtransmitting a plurality of messages shared within the joinedcommunication channels to the client device via the websocketconnection.
 11. The method of claim 7, wherein maintaining the websocketconnection comprises: initializing the websocket connection in responseto a first trigger event to enable transmission of messages to theclient device; closing the websocket connection in response to a secondtrigger event; and storing a plurality of messages in a buffer memorywhile the websocket connection is closed, such that the plurality ofmessages stored in the buffer memory are transmitted to the clientdevice upon initialization of the websocket connection.
 12. The methodof claim 11, wherein the first trigger event is selected from: apredetermined time or receipt of a query from the client device.
 13. Aclient device for displaying messages exchanged within communicationchannels associated with a communication platform, the client devicecomprising: one or more memory storage areas; a display device; and oneor more processors collectively configured to: maintain a firstwebsocket connection to at least one multiplexer, wherein the at leastone multiplexer is configured to maintain a plurality of backendwebsocket connections with the one or more message distribution serversand the plurality of backend websocket connections each correspond witha communication channel; receive a plurality of messages from thecommunication platform via the first websocket connection, wherein eachof the plurality of messages comprise a correspondence tag identifying arespective communication channel for display of the respective messageon the client device within a display window corresponding to thecommunication channel; and display, within a communication channelinterface displayed via the display device, the received plurality ofmessages within respective display windows based at least in part on thecorrespondence tags associated with the messages.
 14. The client deviceof claim 13, wherein displaying the received plurality of messagescomprises: providing each of the plurality of messages to each of aplurality of display windows; and filtering the plurality of messages ateach display window based at least in part on the correspondence tags tostore and display relevant messages at each respective display window.15. The client device of claim 13, wherein displaying the receivedplurality of messages comprises: providing each of the plurality ofmessages to respective display windows based at least in part on thecorrespondence tags associated with the messages; and displaying themessages received at each display window.
 16. The client device of claim13, wherein maintaining the websocket connection comprises: transmittinga query to the communication platform; and initializing the websocketconnection to enable transmission of messages in response to the query.17. A method for displaying messages exchanged within communicationchannels associated with a communication platform via a client device,the method comprising: maintaining a first websocket connection to atleast one multiplexer, wherein the at least one multiplexer isconfigured to maintain a plurality of backend websocket connections withthe one or more message distribution servers and the plurality ofbackend websocket connections each correspond with a communicationchannel; receiving a plurality of messages from the communicationplatform via the first websocket connection, wherein each of theplurality of messages comprise a correspondence tag identifying arespective communication channel for display of the respective messageon the client device within a display window corresponding to thecommunication channel; displaying, within a communication channelinterface displayed via a display device of the client device, thereceived plurality of messages within respective display windows basedat least in part on the correspondence tags associated with themessages.
 18. The method of claim 17, wherein displaying the receivedplurality of messages comprises: providing each of the plurality ofmessages to each of a plurality of display windows; and filtering theplurality of messages at each display window based at least in part onthe correspondence tags to store and display relevant messages at eachrespective display window.
 19. The method of claim 17, whereindisplaying the received plurality of messages comprises: providing eachof the plurality of messages to respective display windows based atleast in part on the correspondence tags associated with the messages;and displaying the messages received at each display window.
 20. Themethod of claim 17, wherein maintaining the websocket connectioncomprises: transmitting a query to the communication platform; andinitializing the websocket connection to enable transmission of messagesin response to the query.
 21. A computer program product fordisseminating messages to client devices in association with acommunication platform, the computer program product comprising at leastone non-transitory computer-readable storage medium havingcomputer-readable program code portions stored therein, thecomputer-readable program code portions comprising an executable portionconfigured to: maintain a websocket connection with a client device inassociation with a communication platform; maintain a plurality ofbackend websocket connections with one or more message distributionservers, wherein the plurality of backend websocket connections eachcorrespond to a communication channel; and transmit a plurality ofmessages shared within respective communication channels from the one ormore message distribution servers to the client device via the websocketconnection, wherein each of the plurality of messages comprises acorrespondence tag identifying a respective communication channel fordisplay of the respective message on the client device within a displaywindow corresponding to the communication channel, wherein each displaywindow is displayed within a communication channel interface displayedvia a display device of the client device.